fix: stop dropping the variables a style's paints and effects bind - #166

Fixes #164.

What was wrong

Figma does not keep a paint's or effect's variable binding in the owning node's
boundVariables — it keeps it on the object itself. serializePaint,
serializeEffect and serializeLayoutGrid each picked a fixed set of fields and
never read it, so a value the designer bound to a variable came back as a plain
literal, indistinguishable from a hard-coded one. get_styles also never read a
TextStyle's own boundVariables, which is the only place a bound
fontSize / lineHeight / letterSpacing exists.

The report names an effect colour; the same drop covered:

What changed

• Each of those objects now carries boundVariables ({ field: variableId }),
  optional, emitted only when something is actually bound.
• get_styles returns a variables table (id → { name, type, codeSyntax? }),
  the same shape get_design_context already returns, leading the result so a
  reader meets an id already knowing what it names. Ids stay the key because
  variable names collide across collections (a local and a library primary).
• A drift ratchet asserts the serializer accounts for every VariableBindable*Field
  family the typings declare, so a future Figma release that makes a new kind of
  object bindable fails CI instead of silently repeating this bug.

Deliberately not done

• Style-level boundVariables (PaintStyle.paints / EffectStyle.effects /
  GridStyle.layoutGrids) is not read. Measured against a live file it is a flat
  VariableAlias[] of whatever is bound somewhere in the array — it names neither
  which paint/effect nor which field — a strictly lossy summary of what the
  per-object bindings now carry exactly.
• get_design_context's globalVars bundles stay unchanged: that is the
  budget-constrained hot path, a node's own boundVariables already names every
  variable its fills/strokes/effects reference (measured: populated both for a
  binding made on the node and for one inherited from a shared style), and all the
  bundle would add is which field of which paint. Pinned by tests.
• The write side. SerializedPaint / SerializedEffect / SerializedLayoutGrid
  are bidirectional, and the write tools ignore boundVariables — documented on the
  schema, with a figma-build rule against writing a literal back over a bound value.
  Round-tripping a binding through set_* / update_* is a separate change.

Measured on a real design system

Run against a production file after the fix, its 23 text styles came back with
69 bindings that were invisible before — every one binds fontSize,
fontStyle and fontFamily — resolved to 15 distinct tokens (size/5xl,
weight/Bold, Font family, …). Two things that file settles:

• Library variables resolve. Ten of the fifteen ids are remote
  (VariableID:<key>/<id>), and getVariableByIdAsync names them — so
  get_styles can name tokens get_variable_defs, which returns local
  variables only, cannot.
• The reported case, reproduced and fixed end to end. A drop shadow whose
  colour and blur were bound in the Figma UI and saved as an effect style now
  returns boundVariables: { color: "VariableID:…", radius: "VariableID:…" }
  next to the literal, with both ids named in variables — one of them a library
  variable carrying the designer's own codeSyntax (var(--sds-size-icon-small)),
  so the consumer gets the project-side token name without a heuristic join.
• Per-object beats the node's own list, measured. The same node reports
  boundVariables: { effects: [id1, id2] } — two ids, no indication which is the
  colour and which is the radius. Only the per-effect map says that. It is the same
  reason the style-level list is not read.
• Names collide, which is why the id stays the key. size/2xl appears twice
  (a local VariableID:1:1253 and a library VariableID:3ad2…/675:134), as does
  weight/Regular. Inlining names into the bindings would have merged two
  different tokens.

Verification

• Raw Figma shapes measured live through the plugin API (not inferred) and used as
  the test fixtures — including the detail a hand-written fixture would never guess:
  an unbound paint carries boundVariables: {}, which must not become an empty
  field in the payload.
• Differential run against the previous serializer: content with no bindings is
  byte-identical; bound content only ever gains a boundVariables key, with
  no existing value changed or removed.
• 18 mutations of the new logic, each confirmed to fail at least one test.
• Every commit builds and passes the full suite on its own.
• Live through the built plugin, on a real design file: a bound node fill, a bound
  shadow (colour + radius) both inline on a node and saved as an effect style, the
  23 text styles, the variables table over local and library variables, and
  codeSyntax. Gradient-stop and layout-grid bindings are covered by unit tests
  against probe-measured shapes rather than end to end — no tool can create either
  binding, so they need a hand-made one in the Figma UI.